home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLSRC.PAK / PROPSHT.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  58.9 KB  |  2,319 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1993, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.34  $
  6. //
  7. // Implementation of TPropertyPage and TPropertySheet classes
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_COMMCTRL_H)
  11. # include <owl/commctrl.h>
  12. #endif
  13. #if !defined(OWL_PROPSHT_H)
  14. # include <owl/propsht.h>
  15. #endif
  16. #if !defined(OWL_TABCTRL_H)
  17. # include <owl/tabctrl.h>
  18. #endif
  19. #if !defined(OWL_RESOURCE_H)
  20. # include <owl/resource.h>
  21. #endif
  22. #if !defined(OWL_PROPSHT_RH)
  23. # include <owl/propsht.rh>
  24. #endif
  25. #if !defined(WINSYS_UIMETRIC_H)
  26. # include <winsys/uimetric.h>
  27. #endif
  28.  
  29. OWL_DIAGINFO;
  30.  
  31. //----------------------------------------------------------------------------
  32. // TPropertySheet
  33. //----------------------------------------------------------------------------
  34.                 
  35. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  36.  
  37. // The caption of the PropertySheet buttons are loaded from a resource (to
  38. // facilitate localization). However, we have default text.
  39. //
  40. static struct TSheetBtnInfo {
  41.   int   id;         // Identifier of button
  42.   int   strId;      // Identifier of string resource of caption
  43.   char* defStr;     // Pointer to default when resource is not found
  44. } defBtn[]= { 
  45.   {ID_APPLY,  IDS_APPLY,  "&Apply"},
  46.   {IDCANCEL,  IDS_CANCEL, "Cancel"},
  47.   {IDOK,      IDS_OK,     "OK"}
  48. }
  49. ,hlpBtn = {IDHELP,    IDS_HELP,   "Help"};
  50.  
  51. const int  defBtnSz  = sizeof(defBtn)/sizeof(defBtn[0]);
  52. const char CloseStr[]= "Close";
  53. #endif
  54.  
  55. //
  56. // Constructs a propertySheet object
  57. //
  58. TPropertySheet::TPropertySheet(TWindow* parent, const char far* title,
  59.                                uint startPage, bool isWizard,
  60.                                uint32 flags, TModule* module)
  61.                : TWindow(parent, title, module), IsWizard(isWizard), 
  62.                  SubClassSheet(false)
  63. {
  64.   // Initialize the structure representing the property sheet
  65.   //
  66.   memset(&HeaderInfo, 0, sizeof(HeaderInfo));
  67.   HeaderInfo.dwSize = sizeof(PROPSHEETHEADER);
  68.   HeaderInfo.dwFlags= flags;
  69.   if (IsWizard)
  70.     HeaderInfo.dwFlags |= PSH_WIZARD;
  71.   HeaderInfo.hInstance = *GetModule();
  72.   HeaderInfo.pszCaption = title;
  73.   HeaderInfo.nStartPage = startPage;
  74.  
  75. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  76.  
  77.   Tab = 0;
  78.   Font = 0;
  79.   ActiveIndex = -1;
  80.   ApplyEnabled = false;
  81.  
  82.   // By default, we'll use the native implementation if it's available
  83.   //
  84.   UseNative = TCommCtrl::IsAvailable();
  85.  
  86.   // ObjectWindows will provide the underlying implementation of
  87.   // PropertySheet/TabControl under environments without the Common 
  88.   // Control Library support
  89.   //
  90.   if (!UseNative) {
  91.     PageRect.SetNull();
  92.  
  93.     // Set the Sheet's window style [Non-native implementation only]
  94.     //
  95.     ModifyStyle(WS_CHILD, WS_POPUP|WS_CAPTION|WS_SYSMENU|
  96.                           WS_VISIBLE|DS_MODALFRAME);
  97.     SetExStyle(WS_EX_DLGMODALFRAME);
  98.   }
  99. #endif
  100. }
  101.  
  102. //
  103. // Clean up resources used by PropertySheet object
  104. //
  105. TPropertySheet::~TPropertySheet()
  106. {
  107. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  108.   delete Font;
  109. #endif  
  110. }
  111.  
  112. //
  113. // Updates the caption of the property sheet
  114. //
  115. void
  116. TPropertySheet::SetCaption(const char far* title)
  117. {
  118. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  119.   //
  120.   // When not using the system's underlying implementation of
  121.   // PropertySheets, TWindow's SetCaption is sufficient.
  122.   //
  123.   if (!UseNative) {
  124.     TWindow::SetCaption(title);
  125.     return;
  126.   }
  127. #endif
  128.  
  129.   // Here we'll be a little flexible and allow a call to SetCaption
  130.   // even before the underlying window element has been created...
  131.   //
  132.   if (GetHandle())
  133.     SetTitle(title, 0);
  134.   else {
  135.     // TWindow's implementation will cache a copy of the string in the
  136.     // data member 'Title'
  137.     //
  138.     TWindow::SetCaption(title);
  139.     HeaderInfo.pszCaption = Title;
  140.   }
  141. }
  142.  
  143. //
  144. // Executes modal propertysheet via call to 'Run' method
  145. //
  146. int
  147. TPropertySheet::Execute()
  148. {
  149. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  150.   //
  151.   // When ObjectWindows is providing the underlying implementation
  152.   // of PropertySheet, we'll simply invoke TWindow's Execute method
  153.   //
  154.   if (!UseNative) {
  155.     return TWindow::Execute();
  156.   }
  157. #endif
  158.  
  159.   // Use CommCtrl via 'Run' helper method
  160.   //
  161.   return Run(true);
  162. }
  163.  
  164. //
  165. // Creates a modeless property sheet.
  166. //
  167. bool
  168. TPropertySheet::Create()
  169. {
  170. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  171.   //
  172.   // When ObjectWindows is providing the underlying implementation
  173.   // of PropertySheet, we'll simply invoke TWindow's Create method
  174.   //
  175.   if (!UseNative)
  176.     return TWindow::Create();
  177. #endif
  178.  
  179.   // Use CommCtrl via 'Run' helper method
  180.   //
  181.   return Run(false) != 0;
  182. }
  183.  
  184. //
  185. // Internal routine use allow each page to register the classes
  186. // of it's children
  187. //
  188. void
  189. TPropertyPage::RegisterPageChildObjects(TPropertyPage* page, void*)
  190. {
  191.   CHECK(page);
  192.   page->RegisterChildObjects();
  193. }
  194.  
  195. //
  196. // Brings up modal/modeless propertysheet by invoking COMMCTRL's API.
  197. //
  198. int
  199. TPropertySheet::Run(bool modal)
  200. {
  201.   // At this point our C++ parent object has (should have!) a valid HWND - 
  202.   // hence update our Header structure
  203.   //
  204.   PRECONDITION(Parent->GetHandle());
  205.   HeaderInfo.hwndParent = Parent->GetHandle();
  206.  
  207.   // We're about to use the Common Control Library's implementation
  208.   // of PropertySheet - Check that it's available
  209.   //
  210.   CHECK(TCommCtrl::IsAvailable());
  211.  
  212.   HPROPSHEETPAGE pHandle[MAXPROPPAGES];
  213.  
  214.   // Have each page give us its handle
  215.   //
  216.   HeaderInfo.nPages = 0;
  217.   HeaderInfo.phpage = pHandle;
  218.   GetPageHandles();
  219.  
  220.   // Have each page register the window classes of it's children
  221.   //
  222.   ForEachPage(TActionPageFunc(TPropertyPage::RegisterPageChildObjects), 0);
  223.  
  224.   // Flag modal vs. modeless sheet
  225.   //
  226.   if (modal) {
  227.     HeaderInfo.dwFlags &= ~PSH_MODELESS;
  228.   }
  229.   else {
  230.     // Subclass the control so that this window will receive
  231.     // button click notifications
  232.     //
  233.     EnableSubclass(true);
  234.     HeaderInfo.dwFlags |= PSH_MODELESS;
  235.   }
  236.  
  237.   // Display property sheet
  238.   //
  239.   return TCommCtrl::Dll()->PropertySheet(&HeaderInfo);
  240. }
  241.  
  242. //
  243. // Internal routine used to add the page handle of a 'TPropertyPage'
  244. // pointer to the array of page handles stored in a PROPSHEETHEADER
  245. // structure.
  246. //
  247. static void
  248. fillPageInfo(TPropertyPage* page, PROPSHEETHEADER* pHeader)
  249. {
  250.   CHECK(page);
  251.   CHECK(pHeader);
  252.   CHECK(pHeader->phpage != 0);
  253.   pHeader->phpage[pHeader->nPages] = page->CreatePropertyPage();
  254.   pHeader->nPages++;
  255. }
  256.  
  257. //
  258. // Have each page of dialog hand over the page handle.
  259. //
  260. bool
  261. TPropertySheet::GetPageHandles()
  262. {
  263. #if defined(__TRACE) || defined(__WARN)
  264.   // Retrieve number of pages in this sheet's child list
  265.   //
  266.   int pageCount = GetPageCount();
  267.  
  268.   // A sheet must have a least one page
  269.   //
  270.   CHECK(pageCount);
  271.   CHECK(pageCount <= MAXPROPPAGES);
  272. #endif
  273.  
  274.   // Have each page hand over it's handle
  275.   //
  276.   ForEachPage(TActionPageFunc(fillPageInfo), &HeaderInfo);
  277.  
  278. #if defined(__TRACE) || defined(__WARN)
  279.   // Double check count
  280.   //
  281.   CHECK(pageCount == HeaderInfo.nPages);
  282. #endif
  283.   return true;
  284. }
  285.  
  286. //
  287. // Applies the specified 'action' function to each TPropertyPage
  288. // child of the Sheet. 
  289. // NOTE: The logic here traverses the TPropertySheet's ChildList. Therefore
  290. //       we will miss any page that does not have an associated TPropertyPage
  291. //       inserted in the sheet's ChildList.
  292. void
  293. TPropertySheet::ForEachPage(TActionPageFunc action, void* paramList)
  294. {
  295.   if (GetLastChild()) {
  296.     TWindow*  curChild;
  297.     TWindow*  nextChild = GetLastChild()->Next();
  298.     TPropertyPage* curPage;
  299.     do {
  300.       curChild = nextChild;
  301.       nextChild = nextChild->Next();
  302.       curPage = TYPESAFE_DOWNCAST(curChild, TPropertyPage);
  303.       if (curPage)
  304.         action(curPage, paramList);
  305.     } while (curChild != GetLastChild() && GetLastChild() != 0);
  306.   }
  307. }
  308.  
  309. //
  310. // Applies the specified 'test' function to each 'TPropertyPage'
  311. // of  the sheet and returns the first page which causes the
  312. // 'test' function to return true. Returns '0' if no page meets
  313. // the condition.
  314. //
  315. TPropertyPage*
  316. TPropertySheet::FirstPageThat(TCondPageFunc test, void* paramList)
  317. {
  318.   if (GetLastChild()) {
  319.     TWindow*  curChild;
  320.     TWindow*  nextChild = GetLastChild()->Next();
  321.     TPropertyPage* curPage;
  322.     do {
  323.       curChild = nextChild;
  324.       nextChild = nextChild->Next();
  325.       curPage = TYPESAFE_DOWNCAST(curChild, TPropertyPage);
  326.       if (curPage) {
  327.         if (test(curPage, paramList))
  328.           return curPage;
  329.       }
  330.     } while (curChild != GetLastChild() && GetLastChild() != 0);
  331.   }
  332.   return 0;
  333. }
  334.  
  335. //
  336. // Internal callback used to count the number of pages within
  337. // a Property Sheet.
  338. //
  339. static void
  340. countPages(TPropertyPage* /*page*/, int* pCount)
  341. {
  342.   (*pCount)++;
  343. }
  344.  
  345. //
  346. // Retrieves the number of pages within a particular sheet
  347. //
  348. int
  349. TPropertySheet::GetPageCount() const
  350. {
  351.   int pageCount = 0;
  352.   CONST_CAST(TPropertySheet*,
  353.              this)->ForEachPage(TActionPageFunc(countPages), &pageCount);
  354.   return pageCount;
  355. }
  356.  
  357. //
  358. // Updates the 'HWINDOW' data member of the PropertySheet Object.
  359. // NOTE: This method is called from the InitHandle method of a
  360. //       page of the sheet.
  361. //
  362. void
  363. TPropertySheet::InitHandle(HWND sheetHandle)
  364. {
  365.   PRECONDITION(GetHandle()==0);
  366.   PRECONDITION(::IsWindow(sheetHandle));
  367.   SetHandle(sheetHandle);
  368.  
  369.   // When using the system's underlying implementation of PropertySheet
  370.   // should we subclass the Sheet or should be it be treated as a black
  371.   // box? Ideally the Sheet is this abstract container and we're only
  372.   // concerned with our pages [dialogs]. However, there are scenarios where
  373.   // we might want to subclass it. For example, if the sheet is used as a 
  374.   // client of a framewindow and 'ShrinkToClient' is enabled, we'll need to
  375.   // detect when the sheet is resized (i.e. receiving WM_SIZE messages) to
  376.   // allow the frame to adjust.
  377.   //
  378.   if (SubClassSheet) {
  379.     SubclassWindowFunction();
  380.     GetHWndState(true);
  381.   }
  382.  
  383.   // Here we 'fake' a SetupWindow call - The typical OWL run-through
  384.   // (i.e. SetupWindow invoked off WM_CREATE) fails in this case since
  385.   // the sheet is created indirectly.
  386.   //
  387.   SetupWindow();
  388. }
  389.  
  390. //
  391. // Adds a new page to the end of the PropertySheet.
  392. // NOTE: The 'pg' must have been created via a call to
  393. //       'TPropertyPage::CreatePropertyPage' before
  394. //       invoking the 'AddPage' method.
  395. // NOTE: The property sheet is not resized to fit the new page. The
  396. //       new page should be no larger that the largest page already
  397. //       in the property sheet.
  398. //
  399. void
  400. TPropertySheet::AddPage(TPropertyPage& pg)
  401. {
  402.   // Update pointer to parent object
  403.   //
  404.   if (pg.GetParentO() != this)
  405.     pg.SetParent(this);
  406.  
  407. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  408.  
  409.   if (!UseNative) {
  410.     // Create the page
  411.     //
  412.     pg.Create();
  413.  
  414.     // Save active page
  415.     //
  416.     TPropertyPage* active = GetActivePage();
  417.  
  418.     // Update tabs to match pages
  419.     // NOTE: Not efficient!! (Revisit and improve)
  420.     //
  421.     SyncTabAndPages();
  422.  
  423.     // Restore active page
  424.     //
  425.     SetActivePage(IndexOfPage(active));
  426.     return;
  427.   }
  428. #endif
  429.  
  430.   // Have page create itself it necessary
  431.   //
  432.   pg.CreatePropertyPage();
  433.   CHECK(HPROPSHEETPAGE(pg));
  434.  
  435.   // Inform sheet about new page
  436.   //
  437.   CHECK(HWND(*this));
  438.   SendMessage(PSM_ADDPAGE, 0, TParam2(HPROPSHEETPAGE(pg)));
  439. }
  440.  
  441. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  442. //
  443. // Internal routine used to send notifications to each page
  444. //
  445. static bool
  446. sendApply(TPropertyPage* pPage, TPshNotify* notInfo)
  447. {
  448.   // Page may not have been created yet!
  449.   //
  450.   if (pPage->GetHandle())
  451.     return pPage->SendNotification(PropPageID, *notInfo) != PSNRET_NOERROR;
  452.   return false;
  453. }
  454. #endif
  455.  
  456. //
  457. // Simulates the choice of the Apply button, indicating that one or more
  458. // pages have changed and the changes need to be validated or recorded.
  459. // The property sheet sends the PSN_KILLACTIVE notification message to the
  460. // current page. If the current page returns FALSE, the propertysheet
  461. // sends the PSN_APPLY notification message to all pages.
  462. // Returns true if all pages successfully applied the changes or false
  463. // otherwise.
  464. //
  465. bool
  466. TPropertySheet::Apply()
  467. {
  468. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  469.   if (!UseNative) {
  470.     TPropertyPage* activePg = GetActivePage();
  471.     TPshNotify info(*this, 0, PSN_KILLACTIVE, 0);
  472.     if (activePg->SendNotification(PropPageID, info) == PSNRET_NOERROR) {
  473.       info.hdr.code = PSN_APPLY;
  474.       TPropertyPage* page = CONST_CAST(TPropertySheet*,
  475.                 this)->FirstPageThat(TCondPageFunc(sendApply), &info);
  476.  
  477.       // Disable Apply button if all pages successfully applied
  478.       //
  479.       if (page == 0) {
  480.         HWND btn = GetDlgItem(ID_APPLY);
  481.         if (btn)
  482.           ::EnableWindow(btn, FALSE);
  483.       }
  484.       return page == 0;
  485.     }
  486.     return false;
  487.   }
  488. #endif
  489.  
  490.   CHECK(HWND(*this));
  491.   return SendMessage(PSM_APPLY) != 0;
  492. }
  493.  
  494. //
  495. // Disables the 'Cancel' button and changes the text of the 'OK' button
  496. // to 'Close'. You must invoke this method after applying a change that
  497. // cannot be canceled.
  498. //
  499. void
  500. TPropertySheet::CancelToClose()
  501. {
  502. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  503.   if (!UseNative) {
  504.     TAPointer<char> p = new char[_MAX_PATH];
  505.     SetDlgItemText(IDOK, GetModule()->LoadString(IDS_CLOSE, p, _MAX_PATH) ? 
  506.                          (char*)p : CloseStr);
  507.     ::EnableWindow(GetDlgItem(IDCANCEL), FALSE);
  508.     return;
  509.   }
  510. #endif
  511.  
  512.   CHECK(HWND(*this));
  513.   SendMessage(PSM_CANCELTOCLOSE);
  514. }
  515.  
  516. //
  517. // Informs the sheet that information in a sheet has changed. The
  518. // sheet enables the 'Apply' button.
  519. //
  520. void
  521. TPropertySheet::PageChanged(const TPropertyPage& pg)
  522. {
  523. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  524.   if (!UseNative) {
  525.     HWND btn = GetDlgItem(ID_APPLY);
  526.     if (btn) {
  527.       if (!::IsWindowEnabled(btn))
  528.         ::EnableWindow(btn, TRUE);
  529.     }
  530.     return;
  531.   }
  532. #endif
  533.  
  534.   PRECONDITION(HPROPSHEETPAGE(pg));
  535.   SendMessage(PSM_CHANGED, TParam1(pg.GetHandle()));
  536. }
  537.  
  538. //
  539. // Retrieves the handle to the window of the current page of the sheet.
  540. //
  541. HWND
  542. TPropertySheet::GetCurrentPage() const
  543. {
  544. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  545.   if (!UseNative) {
  546.     TPropertyPage* activePage = GetActivePage();
  547.     return activePage ? activePage->GetHandle() : 0;  
  548.   }
  549. #endif
  550.  
  551.   return HWND(CONST_CAST(TPropertySheet*,
  552.                          this)->SendMessage(PSM_GETCURRENTPAGEHWND));
  553. }
  554.  
  555. //
  556. // Retrieves the handle to a tab control of a property sheet.
  557. //
  558. HWND
  559. TPropertySheet::GetTabControl() const
  560. {
  561. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  562.   if (!UseNative) {
  563.     PRECONDITION(Tab);
  564.     return Tab->GetHandle();
  565.   }
  566. #endif
  567.  
  568.   CHECK(GetHandle());
  569.   return HWND(CONST_CAST(TPropertySheet*,
  570.                          this)->SendMessage(PSM_GETTABCONTROL));
  571. }
  572.  
  573. //
  574. // Passes a message to a property sheet dialog box and indicates
  575. // whether the dialog processed the message.
  576. // Returns true if the message was processed or false otherwise.
  577. //
  578. bool
  579. TPropertySheet::IsDialogMessage(MSG& msg)
  580. {
  581. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  582.   if (!UseNative) {
  583.     // Not necessary when OWL provides underlying implementation since
  584.     // TPropertySheet can use the 'PreProcessMsg' method to intercept
  585.     // and handle desired events.
  586.     //
  587.     return false;
  588.   }
  589. #endif
  590.  
  591.   CHECK(GetHandle());
  592.   return SendMessage(PSM_ISDIALOGMESSAGE, 0, TParam2(&msg)) != 0;
  593. }
  594.  
  595. //
  596. // Simulates the choice of a property sheet button.
  597. // The button parameter can be one of the following:
  598. //
  599. //    PSBTN_APPLYNOW      Apply Now button.
  600. //    PSBTN_BACK          Back button.
  601. //    PSBTN_CANCEL        Cancel button.
  602. //    PSBTN_FINISH        Finish button.
  603. //    PSBTN_HELP          Help button.
  604. //    PSBTN_NEXT          Next button.
  605. //    PSBTN_OK            OK button
  606. //
  607. void
  608. TPropertySheet::PressButton(int button)
  609. {
  610. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  611.   if (!UseNative) {
  612.     uint id = 0;
  613.     switch (button) {
  614.       case PSBTN_APPLYNOW: id = ID_APPLY;  break;
  615.       case PSBTN_BACK:     id = ID_BACK;   break;
  616.       case PSBTN_CANCEL:   id = IDCANCEL;  break;
  617.       case PSBTN_FINISH:   id = ID_FINISH; break;
  618.       case PSBTN_HELP:     id = IDHELP;    break;
  619.       case PSBTN_NEXT:     id = ID_NEXT;   break;
  620.       case PSBTN_OK:       id = IDOK;      break;
  621.     }
  622.     if (id) {
  623.       // Could optimize here and use HandleMessage instead to avoid
  624.       // going through Windows msg. queue.
  625.       //
  626.       SendNotification(id, BN_CLICKED, GetDlgItem(id));
  627.     }
  628.     return;
  629.   }
  630. #endif
  631.   CHECK(GetHandle());
  632.   SendMessage(PSM_PRESSBUTTON, TParam1(button));
  633. }
  634.  
  635. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  636. //
  637. // Internal routine used to send notifications to each page
  638. //
  639. static bool
  640. sendQuerySiblings(TPropertyPage* pPage, MSG* msg)
  641. {
  642.   LRESULT result = pPage->SendMessage(PSM_QUERYSIBLINGS, msg->wParam, 
  643.                                                          msg->lParam);
  644.   if (result) {
  645.     msg->lParam = result;
  646.     return true;
  647.   }
  648.   return false;
  649. }
  650. #endif
  651.  
  652. //
  653. // Forwards the 'PSM_QUERYSIBLINGS' message to each page in the
  654. // property sheet. If a page returns a nonzeroe value, the property
  655. // sheet does not send the message to subsequent pages.
  656. // Returns the nonzero value from a page in the property sheet, or
  657. // zero if no page returns a nonzero value.
  658. //
  659. int
  660. TPropertySheet::QuerySiblings(TParam1 p1, TParam2 p2)
  661. {
  662. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  663.   if (!UseNative) {
  664.     MSG msg;
  665.     msg.message = PSM_QUERYSIBLINGS;
  666.     msg.wParam  = p1;
  667.     msg.lParam  = p2;
  668.     TPropertyPage* page = CONST_CAST(TPropertySheet*,
  669.               this)->FirstPageThat(TCondPageFunc(sendQuerySiblings), &msg);
  670.     return page ? int(msg.lParam) : 0;
  671.   }
  672. #endif
  673.   CHECK(GetHandle());
  674.   return (int)SendMessage(PSM_QUERYSIBLINGS, p1, p2);
  675. }
  676.  
  677. //
  678. // Indicates that the system needs to be restarted for the changes
  679. // to take effect. You should invoke this method only in response to
  680. // the PSN_APPLY or PSN_KILLACTIVE notifications.
  681. // NOTE: It's your responsibility to reboot the system [via ExitWindowEx
  682. //       for example].
  683. // NOTE: Invoking this method causes the TPropertySheet::Execute method
  684. //       to return ID_PSREBOOTSYSTEM.
  685. //
  686. void
  687. TPropertySheet::RebootSystem()
  688. {
  689. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  690.   if (!UseNative) {
  691.     if (IsFlagSet(wfModalWindow))
  692.       CloseWindow(ID_PSREBOOTSYSTEM);
  693.     return;
  694.   }
  695. #endif
  696.  
  697.   CHECK(GetHandle());
  698.   SendMessage(PSM_REBOOTSYSTEM);
  699. }
  700.  
  701. //
  702. // Removes the specified page from the property sheet
  703. //
  704. void
  705. TPropertySheet::RemovePage(TPropertyPage& pg)
  706. {
  707. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  708.   if (!UseNative) {
  709.     if (pg.GetSheet() == this) {
  710.       int index = IndexOfPage(&pg);
  711.       if (index != -1) {
  712.         pg.Destroy(-1);
  713.         Tab->Delete(index);
  714.         if (index == ActiveIndex && GetPageCount())
  715.           SetActivePage((ActiveIndex+1) % GetPageCount());
  716.       }
  717.     }
  718.     return;
  719.   }
  720. #endif
  721.  
  722.   PRECONDITION(HPROPSHEETPAGE(pg));
  723.   CHECK(GetHandle());
  724.   SendMessage(PSM_REMOVEPAGE, 0, TParam2(HPROPSHEETPAGE(pg)));
  725.   //
  726.   // Should we actually invoke 'DestroyPropertySheetPage' for
  727.   // Pages which are added then removed from the PropertySheet??
  728. }
  729.  
  730. //
  731. // Removes the page at the specified index from the property sheet
  732. //
  733. void
  734. TPropertySheet::RemovePage(int pgIndex)
  735. {
  736. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  737.   if (!UseNative) {
  738.     TPropertyPage* page = PageAtIndex(pgIndex);
  739.     if (page)
  740.       RemovePage(*page);
  741.     return;
  742.   }
  743. #endif
  744.  
  745.   CHECK(GetHandle());
  746.   SendMessage(PSM_REMOVEPAGE, pgIndex);
  747.   //
  748.   // Should we actually invoke 'DestroyPropertySheetPage' for
  749.   // Pages which are added then removed from the PropertySheet??
  750. }
  751.  
  752. //
  753. // Indicates that the system needs to be restarted for the changes
  754. // to take effect. You should invoke this method only in response to
  755. // the PSN_APPLY or PSN_KILLACTIVE notifications.
  756. // NOTE: It's your responsibility to reboot the system [via ExitWindowEx
  757. //       for example].
  758. // NOTE: Invoking this method causes the TPropertySheet::Execute method
  759. //       to return ID_PSRESTARTWINDOWS.
  760. //
  761. void
  762. TPropertySheet::RestartWindows()
  763. {
  764. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  765.   if (!UseNative) {
  766.     if (IsFlagSet(wfModalWindow))
  767.       CloseWindow(ID_PSRESTARTWINDOWS);
  768.     return;
  769.   }
  770. #endif
  771.  
  772.   CHECK(GetHandle());
  773.   SendMessage(PSM_RESTARTWINDOWS);
  774. }
  775.  
  776. //
  777. // Activates the specified page in the property sheet
  778. // Returns true if successful or false otherwise.
  779. // NOTE: The page that's loosing activation receives a PSN_KILLACTIVE
  780. //       notification while the window that's gaining activation receives
  781. //       a PSN_SETACTIVE notification.
  782. //
  783. bool
  784. TPropertySheet::SelectPage(TPropertyPage& pg)
  785. {
  786. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  787.   if (!UseNative) {
  788.     TPshNotify info(*this, 0, PSN_KILLACTIVE, 0);
  789.     TPropertyPage* page = GetActivePage();
  790.     if (page && page->SendNotification(PropPageID, info) != PSNRET_NOERROR) 
  791.       return false;
  792.  
  793.     int index = IndexOfPage(&pg);
  794.     if (index != -1) {
  795.       SetActivePage(index);
  796.       info.hdr.code = PSN_SETACTIVE;
  797.       pg.SendNotification(PropPageID, info);
  798.       return true;
  799.     }
  800.     return false;
  801.   }
  802. #endif
  803.  
  804.   PRECONDITION(GetHandle());
  805.   PRECONDITION(HPROPSHEETPAGE(pg));
  806.   return SendMessage(PSM_SETCURSEL, 0, TParam2(HPROPSHEETPAGE(pg))) != 0;
  807. }
  808.  
  809. //
  810. // Activates the page at the specified index in the property sheet.
  811. // Returns true if successful or false otherwise.
  812. // NOTE: The page that's loosing activation receives a PSN_KILLACTIVE
  813. //       notification while the window that's gaining activation receives
  814. //       a PSN_SETACTIVE notification.
  815. //
  816. bool
  817. TPropertySheet::SelectPage(int pgIndex)
  818. {
  819. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  820.   if (!UseNative) {
  821.     PRECONDITION(pgIndex < GetPageCount());
  822.     TPropertyPage* page = PageAtIndex(pgIndex);
  823.     if (page)
  824.       return SelectPage(*page);
  825.     return false;
  826.   }
  827. #endif
  828.  
  829.   PRECONDITION(GetHandle());
  830.   return SendMessage(PSM_SETCURSEL, TParam1(pgIndex)) != 0;
  831. }
  832.  
  833. //
  834. // Activates the page with the specified resource identifier.
  835. // Returns true if successful or false otherwise.
  836. // NOTE: The page that's loosing activation receives a PSN_KILLACTIVE
  837. //       notification while the window that's gaining activation receives
  838. //       a PSN_SETACTIVE notification.
  839. //
  840. bool
  841. TPropertySheet::SelectPage(TResId pgRes)
  842. {
  843. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  844.   if (!UseNative) {
  845.     // This flavour of page selection is not supported by the ObjectWindows
  846.     // emulation of PropertySheet/PropertyPage. 
  847.     return false;
  848.   }
  849. #endif
  850.  
  851.   CHECK(GetHandle());
  852.   return SendMessage(PSM_SETCURSELID, 0, TParam2((char far*)pgRes));
  853. }
  854.  
  855. //
  856. // Sets the text for the 'Finish' button in a Wizard property sheet.
  857. // NOTE: The button is enabled while the 'Next' and 'Back' buttons
  858. //       are hidden.
  859. //
  860. void
  861. TPropertySheet::SetFinishText(const char far* txt)
  862. {
  863. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  864.   if (!UseNative) {
  865.     HWND finish = GetDlgItem(ID_FINISH);
  866.     HWND next   = GetDlgItem(ID_NEXT);
  867.     HWND back   = GetDlgItem(ID_BACK);
  868.     if (finish)
  869.       ::SetWindowText(finish, txt);
  870.     if (next)
  871.       ::EnableWindow(next, FALSE);  // Disable (rather than hide)
  872.     if (back)
  873.       ::EnableWindow(back, FALSE);  // Disable (rather than hide)
  874.     return;
  875.   }
  876. #endif
  877.  
  878.   CHECK(GetHandle());
  879.   SendMessage(PSM_SETFINISHTEXT, 0, TParam2(txt));
  880. }
  881.  
  882. //
  883. // Sets the title of a property sheet.
  884. // If 'style' parameter is the PSH_PROPTITLE value, the prefix
  885. // "Properties of" is included with the specified title ('txt')
  886. // parameter.
  887. //
  888. void
  889. TPropertySheet::SetTitle(const char far* txt, uint32 style)
  890. {
  891. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  892.   if (!UseNative) {
  893.     SetWindowText(txt);
  894.     return;
  895.   }
  896. #endif
  897.  
  898.   CHECK(GetHandle());
  899.   SendMessage(PSM_SETTITLE, TParam1(style), TParam2(txt));
  900. }
  901.  
  902. //
  903. // Enables the 'Back', 'Next' or 'Finish' button in a wizard
  904. // property sheet. The 'flags' parameter can be a combination of
  905. // the following values:
  906. //
  907. //          PSWIZB_BACK                 Back button
  908. //          PSWIZB_NEXT                 Next button
  909. //          PSWIZB_FINISH               Finish button
  910. //
  911. void
  912. TPropertySheet::SetWizButtons(uint32 flags)
  913. {
  914. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  915.   if (!UseNative) {
  916.     HWND finish = GetDlgItem(ID_FINISH);
  917.     HWND next   = GetDlgItem(ID_NEXT);
  918.     HWND back   = GetDlgItem(ID_BACK);
  919.     if (back)
  920.       ::EnableWindow(back, (flags & PSWIZB_BACK) ? TRUE : FALSE);
  921.     if (next)
  922.       ::EnableWindow(next, (flags & PSWIZB_NEXT) ? TRUE : FALSE);
  923.     if (finish)
  924.       ::EnableWindow(finish, (flags & PSWIZB_FINISH) ? TRUE : FALSE);
  925.     return;
  926.   }
  927. #endif
  928.  
  929.   CHECK(GetHandle());
  930.   SendMessage(PSM_SETWIZBUTTONS, 0, TParam2(flags));
  931. }
  932.  
  933. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  934. //
  935. // Internal routine used to check if there's a dirty page
  936. //
  937. static bool
  938. isModified(TPropertyPage* pPage, void*)
  939. {
  940.   return pPage->IsModified();
  941. }
  942. #endif
  943.  
  944. //
  945. // Informs the sheet that the information in the specified page
  946. // has reverted to the previously saved state. The sheet disables
  947. // the 'Apply' button if no other pages have registered changes
  948. // with the property sheet.
  949. //
  950. void
  951. TPropertySheet::PageUnchanged(TPropertyPage& pg)
  952. {
  953. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  954.   if (!UseNative) {
  955.  
  956.     // Update the specified page
  957.     //
  958.     pg.SetModified(false);
  959.  
  960.     // Find out if there are any dirty pages
  961.     //
  962.     TPropertyPage* page = CONST_CAST(TPropertySheet*,
  963.                           this)->FirstPageThat(isModified, 0);
  964.  
  965.     // Disable APPLY button if all pages are clean
  966.     //
  967.     if (!page) {
  968.       HWND apply = GetDlgItem(ID_APPLY);
  969.       if (apply)
  970.         ::EnableWindow(apply, FALSE);
  971.     }
  972.     return;
  973.   }
  974. #endif
  975.  
  976.   PRECONDITION(HPROPSHEETPAGE(pg));
  977.   CHECK(GetHandle());
  978.   SendMessage(PSM_UNCHANGED, TParam1(pg.GetHandle()));
  979. }
  980.  
  981. //
  982. //
  983. //
  984. bool
  985. TPropertySheet::PreProcessMsg(MSG& msg) {
  986.  
  987.   // If current page = 0, then it's time to close the property sheet.
  988.   // 
  989.   HWND page = GetCurrentPage();
  990.   if (!page) {
  991.     CloseWindow();
  992.     return false;
  993.   } 
  994.   else {
  995.     return TWindow::PreProcessMsg(msg);
  996.   }
  997. }
  998.  
  999. // ---------------------------------------------------------------------------
  1000. //  TPropertyPage
  1001. // ---------------------------------------------------------------------------
  1002.  
  1003. DEFINE_RESPONSE_TABLE1(TPropertyPage, TDialog)
  1004.   EV_PSN_SETACTIVE(SetActive),
  1005.   EV_PSN_KILLACTIVE(KillActive),
  1006.   EV_PSN_APPLY(Apply),
  1007.   EV_PSN_RESET(Reset),
  1008.   EV_PSN_HELP(Help),
  1009.   EV_PSN_WIZBACK(WizBack),
  1010.   EV_PSN_WIZFINISH(WizFinish),
  1011.   EV_PSN_WIZNEXT(WizNext),
  1012.   EV_PSN_QUERYCANCEL(QueryCancel),
  1013.  
  1014.   EV_COMMAND(IDOK, CmOk),
  1015.   EV_COMMAND(IDCANCEL, CmCancel),
  1016. END_RESPONSE_TABLE;
  1017.  
  1018. //
  1019. // Constructor for TPropertyPage
  1020. //
  1021. //
  1022. TPropertyPage::TPropertyPage(TPropertySheet* parent, TResId resId,
  1023.                              const char far* title, TResId iconRes,
  1024.                              TModule* module)
  1025. : 
  1026.   TDialog(parent, resId, module), HPropPage(0)
  1027. {
  1028.   // Initialize the PROPSHEETPAGE structure
  1029.   // NOTE: We're storing the 'this' pointer in the application-defined
  1030.   //       section of the PROPSHEETPAGE structure...
  1031.   //
  1032.   memset(&PageInfo, 0, sizeof(PageInfo));
  1033.   PageInfo.dwSize = sizeof(PROPSHEETPAGE);
  1034.   PageInfo.dwFlags= PSP_DEFAULT;
  1035.   PageInfo.pszTemplate = resId;
  1036.   PageInfo.hInstance = *GetModule();
  1037.  
  1038.   if (title)
  1039.     SetTitle(title);
  1040.   if (iconRes)
  1041.     SetIcon(iconRes);
  1042.  
  1043.   PageInfo.dwFlags |= PSP_USECALLBACK;
  1044.   PageInfo.pfnCallback = PropCallback;
  1045.   PageInfo.pfnDlgProc = PropDlgProc;
  1046.   PageInfo.lParam = LPARAM(this);
  1047.  
  1048. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  1049.  
  1050.   Modified = false;
  1051.  
  1052.   // By default, we'll use the native implementation if it's available
  1053.   //
  1054.   UseNative = TCommCtrl::IsAvailable();
  1055.  
  1056. #else
  1057.   // When OWL is built with the NATIVECTRL_ALWAYS option or in 32-bit the
  1058.   // Common Control library MUST be available....
  1059.   //
  1060.   CHECK(TCommCtrl::IsAvailable());
  1061. #endif
  1062. }
  1063.  
  1064.  
  1065. //
  1066. // Destructor of TPropertyPage - Clean up allocated buffers used when
  1067. // ObjectWindows provides implementation of property pages.
  1068. //
  1069. TPropertyPage::~TPropertyPage()
  1070. {}
  1071.  
  1072. //
  1073. // Specifies flags to be used in creating the property page.  These
  1074. // are the flags that belong in PROPSHEETPAGE.dwFlags.  If used, this 
  1075. // method should be called immediately after the TPropertyPage is 
  1076. // constructed.
  1077. //
  1078. void
  1079. TPropertyPage::SetFlags(uint32 flags)
  1080. {
  1081.   PageInfo.dwFlags = flags;
  1082. }
  1083.  
  1084. //
  1085. // Specifies the icon to be used for this page
  1086. // NOTE: This routine must be invoked before the page is created.
  1087. //
  1088. void
  1089. TPropertyPage::SetIcon(const TIcon& icon)
  1090. {
  1091.   PageInfo.hIcon = icon;
  1092.   PageInfo.dwFlags &= ~PSH_USEICONID;
  1093.   PageInfo.dwFlags |=  PSH_USEHICON;
  1094. }
  1095.  
  1096. //
  1097. // Specifies the icon to be used for this page
  1098. // NOTE: This routine must be invoked before the page is created.
  1099. //
  1100. void
  1101. TPropertyPage::SetIcon(TResId iconResId)
  1102. {
  1103.   PageInfo.pszIcon = iconResId;
  1104.   PageInfo.dwFlags &= ~PSH_USEHICON;
  1105.   PageInfo.dwFlags |=  PSH_USEICONID;
  1106. }
  1107.  
  1108. //
  1109. // Sets the caption of this page.
  1110. // NOTE: This routine must be invoked before the page is created.
  1111. //
  1112. void
  1113. TPropertyPage::SetTitle(const char far* title)
  1114. {
  1115.   // Let TWindow make a copy of the title to 'Title'
  1116.   // Then point to the 'duped' copy...
  1117.   //
  1118.   SetCaption(title);
  1119.   PageInfo.pszTitle = Title;
  1120.   PageInfo.dwFlags |= PSP_USETITLE;
  1121. }
  1122.  
  1123. //
  1124. // Sets the caption of this page.
  1125. // NOTE: This routine must be invoked before the page is created.
  1126. //
  1127. void
  1128. TPropertyPage::SetTitle(int txtResId)
  1129. {
  1130.   PageInfo.pszTitle = MAKEINTRESOURCE(txtResId);
  1131.   PageInfo.dwFlags &= ~PSP_USETITLE;
  1132. }
  1133.  
  1134. //
  1135. // WM_NOTIFY handler: Scans for property sheet notifications to 'patch'
  1136. // the 'idFrom' member to the predefined 'PropPageID'.
  1137. // NOTE: This is necessary since WM_NOTIFY subdispatching relies on the
  1138. //       id of the sender.
  1139. //
  1140. TResult
  1141. TPropertyPage::EvNotify(uint id, TNotify& notifyInfo)
  1142. {
  1143.   if (notifyInfo.code <= PSN_FIRST && notifyInfo.code >= PSN_LAST) {
  1144.     // Property sheet notifications require special handling since the
  1145.     // concept of ctlId is non-existent. We patch it to the default
  1146.     // PageID expected by the ObjectWindows Property Page dispatchers
  1147.     //
  1148.     notifyInfo.idFrom = PropPageID;
  1149.     id = PropPageID;
  1150.  
  1151.     // Also make sure we don't reflect the message back to what looks like
  1152.     // the 'child' sender but is really the sheet. We achieve this by
  1153.     // NULLing out the HWND of the sender.
  1154.     //
  1155.     notifyInfo.hwndFrom = 0;
  1156.   }
  1157.   return TDialog::EvNotify(id, notifyInfo);
  1158. }
  1159.  
  1160. //
  1161. // This callback is the default 'Dialog box procedure' of each page of our
  1162. // property sheet....
  1163. //
  1164. int CALLBACK OWL_EXPORT16
  1165. TPropertyPage::PropDlgProc(HWND hDlg, uint msg, WPARAM wParam, LPARAM lParam)
  1166. {
  1167.   switch(msg) {
  1168.     case  WM_INITDIALOG: {
  1169.             // Attach C++ object with it's underlying handle if necessary
  1170.             //
  1171.             LPPROPSHEETPAGE pageInfo = REINTERPRET_CAST(LPPROPSHEETPAGE,
  1172.                                                         lParam);
  1173.             InitHandle(hDlg, pageInfo);
  1174.           }
  1175.           break;
  1176.  
  1177.     case WM_NOTIFY: {
  1178.           TNotify& notifyInfo= *(REINTERPRET_CAST(TNotify*, lParam));
  1179.           if (notifyInfo.code <= PSN_FIRST && notifyInfo.code >= PSN_LAST) {
  1180.  
  1181.               // Property sheet notifications require special handling
  1182.               // since the concept of ctlId is non-existent. We patch it
  1183.               // to the default PageID expected by the ObjectWindows
  1184.               // Property Page dispatchers
  1185.               //
  1186.               notifyInfo.idFrom = PropPageID;
  1187.               wParam = PropPageID;
  1188.             }
  1189.           }
  1190.           break;
  1191.  
  1192.     default:
  1193.           break;
  1194.   }
  1195.  
  1196.   return TDialog::StdDlgProc(hDlg, msg, wParam, lParam);
  1197. }
  1198.  
  1199. //
  1200. // As with TDialog, most of the page's events are dispatch
  1201. // directly from 'StdWndProc'. ALthough the Sheet has each
  1202. // page's DialogProc, the notifications are not (don't seem
  1203. // to be) funelled directly to the dialogProc
  1204. //
  1205. bool
  1206. TPropertyPage::DialogFunction(uint msg, TParam1 p1, TParam2 p2)
  1207. {
  1208.   switch(msg) {
  1209.     case WM_NOTIFY: {
  1210.            NMHDR& nmhdr = *(REINTERPRET_CAST(NMHDR far*, p2));
  1211.            if (nmhdr.code >= PSN_LAST && nmhdr.code <= PSN_FIRST) {
  1212.              CHECK(p1 != 0);
  1213.              CHECK(nmhdr.idFrom != 0);
  1214.            }
  1215.          }
  1216.          break;
  1217.  
  1218.     default:
  1219.         break;
  1220.   }
  1221.   return TDialog::DialogFunction(msg, p1, p2);
  1222. }
  1223.  
  1224. // 'CopyPageInfo' is called by the 'Sheet' object requesting
  1225. // the page to fill out a 'PROPSHEETPAGE' structure which
  1226. // describes the attribute of the page.
  1227. //
  1228. void
  1229. TPropertyPage::CopyPageInfo(PROPSHEETPAGE& pgInfo) const
  1230. {
  1231.   pgInfo = PageInfo;
  1232. }
  1233.  
  1234. //
  1235. // 'CreatePropertyPage' is called by the 'Sheet' object requesting
  1236. // the page to return a handle used to represent this dialog
  1237. // when it's inserted into the 'Sheet'
  1238. //
  1239. HPROPSHEETPAGE
  1240. TPropertyPage::CreatePropertyPage()
  1241. {
  1242.   if (!HPropPage) 
  1243.     HPropPage = TCommCtrl::Dll()->CreatePropertySheetPage(&PageInfo);
  1244.  
  1245.   return HPropPage;
  1246. }
  1247.  
  1248. //
  1249. // Destroys the page represented by this object.
  1250. //
  1251. bool
  1252. TPropertyPage::DestroyPropertyPage()
  1253. {
  1254.   PRECONDITION(HPropPage);
  1255.   if (TCommCtrl::Dll()->DestroyPropertySheetPage(HPropPage)) {
  1256.     HPropPage= 0;
  1257.     return true;
  1258.   }
  1259.   return false;
  1260. }
  1261.  
  1262. //
  1263. // Creates the page
  1264. //
  1265. bool
  1266. TPropertyPage::Create()
  1267. {
  1268. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  1269.   //
  1270.   // If we're using ObjectWindows' implementation of PropertySheet/Page,
  1271.   // simply chain to the default TDialog::Create method
  1272.   //
  1273.   if (!UseNative)
  1274.     return TDialog::Create();
  1275. #endif
  1276.  
  1277.   // When using the system's implementation if PropertyDialogs, the page
  1278.   // is actually created behind the scene when the PropertySheet is
  1279.   // created. The callbacks specified by ObjectWindows [PropDlgProc &
  1280.   // PropCallback] will update the TPropertyPage's HWindow data member.
  1281.   //
  1282.   // Therefore, our 'Create' method simply checks that the handle was
  1283.   // indeed initialized and happily returns true.
  1284.   //
  1285.   CHECK(GetHandle() != 0);
  1286.   return true;
  1287. }
  1288.  
  1289. //
  1290. // The pages of a propertysheet are created internally by windows...
  1291. // Consequently, we must attempt to grab and thunk the 'HWND' as
  1292. // early as possible. There are two basic opportunities to do so:
  1293. //
  1294. // (a) A Sheet can provide a callback which is called whenever a
  1295. //     page is created or released. Hence 'TPropertyPage::PropCallback'
  1296. //     invokes 'InitHandle'.
  1297. //
  1298. // (b) Each page provides a dialog-procedure callback. Hence,
  1299. //     'TPropertyPage::PropDlgProc' invokes 'InitHandle' upon receiving
  1300. //     a WM_INITDIALOG message.
  1301. //
  1302. void
  1303. TPropertyPage::InitHandle(HWND pageHandle, LPPROPSHEETPAGE ppsp)
  1304. {
  1305.   // First check that the lParam data member of the PROPSHEETPAGE
  1306.   // contains a 'this' pointer to an OWL TPropertyPage object
  1307.   // wrapping the dialog
  1308.   //
  1309.   TPropertyPage* page = REINTERPRET_CAST(TPropertyPage*, ppsp->lParam);
  1310.  
  1311.   if (page && pageHandle) {
  1312.     // Only proceed if the C++ object is not fully initialized
  1313.     //
  1314.     if (page->GetHandle()) {
  1315.       CHECK(page->GetHandle() == pageHandle);
  1316.       return;
  1317.     }
  1318.  
  1319.     // Proceed to initialize the handle of the page object.
  1320.     //
  1321.     page->SetHandle(pageHandle);
  1322.  
  1323.     // We can now retrieve the pointer to the sheet object
  1324.     // and initialize the latter if necessary.
  1325.     //
  1326.     TPropertySheet* sheet = page->GetSheet();
  1327.     if (sheet) {
  1328.       if (!sheet->GetHandle()) {
  1329.         HWND sheetHandle = ::GetParent(pageHandle);
  1330.         if (sheetHandle)
  1331.           sheet->InitHandle(sheetHandle);
  1332.       }
  1333.     }
  1334.  
  1335.     // Allow OWL to thunk the page window.
  1336.     //
  1337.     page->SubclassWindowFunction();
  1338.  
  1339.     // NOTE: Typically, we'd call 'GetHWndState', 'PerformDlgInit',
  1340.     //       'SetupWindow' and 'SetFlag(wfFullyCreated)' after
  1341.     //       thunking a window. However, TDialog's 'EvInitDialog'
  1342.     //       method [invoked via the PropDlgProc callback] will
  1343.     //       handle that.
  1344.   }
  1345. }
  1346.  
  1347. //
  1348. // Static callback invoked whenever a Property Page is created is
  1349. // destroyed.
  1350. //
  1351. uint CALLBACK OWL_EXPORT16
  1352. TPropertyPage::PropCallback(HWND hwnd, uint uMsg, LPPROPSHEETPAGE ppsp)
  1353. {
  1354.   switch (uMsg) {
  1355.     case PSPCB_CREATE: {
  1356.  
  1357.            // A Property Page was just created.. We'll attempt to thunk
  1358.            // the underlying 'HWND' if it was specified..
  1359.            //
  1360.            if (hwnd)
  1361.              InitHandle(hwnd, ppsp);
  1362.          }
  1363.          break;
  1364.  
  1365.     case PSPCB_RELEASE: {
  1366.  
  1367.             // A Property Page was just released... Currently, we
  1368.             // don't have any processing to do here....
  1369.             // Should we invoke a virtual method of TPropertyPage
  1370.             // from here - just in case a page needs to do something
  1371.             // when it's released or are the default ObjectWindows
  1372.             // mechanisms (CleanupWindow & Destructor) sufficient....
  1373.             //
  1374.          }
  1375.          break;
  1376.  
  1377.     default:
  1378.           break;
  1379.   }
  1380.   // The return is ignored for PSPCB_RELEASE (according to the doc).
  1381.   // A non-zero value allows the page to be created...
  1382.   //
  1383.   return 1;
  1384. }
  1385.  
  1386. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  1387. //
  1388. // Returns the caption of a PropertyPage
  1389. // May be used for PropertyPages with or without an underlying
  1390. // window element.
  1391. //
  1392. bool
  1393. TPropertyPage::GetPageCaption(char* txt, int size)
  1394. {
  1395.   // This method should only be invoked when ObjectWindows
  1396.   // is providing the underlying implementation of Property Page.
  1397.   //
  1398.   CHECK(!UseNative);
  1399.  
  1400.   // Retrieve actual text if page has been created
  1401.   //
  1402.   if (GetHandle()) {
  1403.     return GetWindowText(txt, size) != 0;
  1404.   }
  1405.   else {
  1406.     if ((PageInfo.dwFlags & PSP_USETITLE) && Title) {
  1407.       strncpy(txt, Title, size);
  1408.     }
  1409.     else {
  1410.       PRECONDITION((char*)ResCaption && *((char*)ResCaption));
  1411.       strncpy(txt, ResCaption, size);
  1412.     }
  1413.   }
  1414.   return true;
  1415. }
  1416.  
  1417. //
  1418. // Sets the caption of a PropertyPage
  1419. //
  1420. void
  1421. TPropertyPage::SetPageCaption(char far* caption)
  1422. {
  1423.   PRECONDITION(caption);
  1424.   PRECONDITION(*caption);
  1425.  
  1426.   // This method should only be invoked when ObjectWindows
  1427.   // is providing the underlying implementation of Property Page.
  1428.   //
  1429.   CHECK(!UseNative);
  1430.   ResCaption = nstrnewdup(caption);
  1431. }
  1432.  
  1433. #endif
  1434.  
  1435. // Default implementation of PropertySheet notifications.. Derived classes
  1436. // will override - most likely.
  1437. //
  1438.  
  1439. //
  1440. //
  1441. //
  1442. int
  1443. TPropertyPage::Apply(TNotify&)
  1444. {
  1445. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  1446.   if (!UseNative) {
  1447.     // Clear modified flag 
  1448.     //
  1449.     SetModified(false);
  1450.   }
  1451. #endif
  1452.  
  1453.   // Check if it's OK to close and attempt to retrieve data
  1454.   //
  1455.   if (CanClose()) {
  1456.     TransferData(tdGetData);
  1457.     return PSNRET_NOERROR;
  1458.   }
  1459.  
  1460.   // It's not OK to proceed - return focus to this page
  1461.   //
  1462.   return PSNRET_INVALID_NOCHANGEPAGE;
  1463. }
  1464.  
  1465. //
  1466. //
  1467. //
  1468. bool
  1469. TPropertyPage::KillActive(TNotify&)
  1470. {
  1471.   return false;
  1472. }
  1473.  
  1474. //
  1475. //
  1476. //
  1477. void
  1478. TPropertyPage::Help(TNotify&)
  1479. {
  1480. }
  1481.  
  1482. //
  1483. //
  1484. //
  1485. void
  1486. TPropertyPage::Reset(TNotify&)
  1487. {
  1488. }
  1489.  
  1490. //
  1491. //
  1492. //
  1493. int
  1494. TPropertyPage::SetActive(TNotify&)
  1495. {
  1496.   return 0;
  1497. }
  1498.  
  1499. //
  1500. //
  1501. //
  1502. int
  1503. TPropertyPage::WizBack(TNotify&)
  1504. {
  1505.   return 0;
  1506. }
  1507.  
  1508. //
  1509. //
  1510. //
  1511. bool
  1512. TPropertyPage::WizFinish(TNotify&)
  1513. {
  1514.   return false;
  1515. }
  1516.  
  1517. //
  1518. //
  1519. //
  1520. int
  1521. TPropertyPage::WizNext(TNotify&)
  1522. {
  1523.   return 0;
  1524. }
  1525.  
  1526. //
  1527. //
  1528. //
  1529. bool
  1530. TPropertyPage::QueryCancel(TNotify&)
  1531. {
  1532.   return false;
  1533. }
  1534.  
  1535. // ------------------------------------------------------------------------
  1536. // The following routines are used by ObjectWindows when it
  1537. // provides the underlying support for PropertyPage
  1538. // ------------------------------------------------------------------------
  1539. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  1540.  
  1541. //
  1542. // Responds to an incoming notification message from a button with
  1543. // an Id equal to IDOK
  1544. //
  1545. void
  1546. TPropertyPage::CmOk()
  1547. {
  1548.   if (!UseNative) {
  1549.     TPropertySheet* sheet = GetSheet();
  1550.     if (sheet) {
  1551.       sheet->Apply();
  1552.       sheet->CloseWindow(IDOK);
  1553.     }
  1554.   }
  1555.   else
  1556.     DefaultProcessing();
  1557. }
  1558.  
  1559. //
  1560. //
  1561. void
  1562. TPropertyPage::CmCancel()
  1563. {
  1564.   TPropertySheet* sheet = GetSheet();
  1565.   if (sheet)
  1566.     sheet->CloseWindow(IDCANCEL);
  1567. }
  1568.  
  1569. //
  1570. // Update the style/size of the dialog [PropertyPage]
  1571. //
  1572. void
  1573. TPropertyPage::SetupWindow()
  1574. {
  1575.   // Chain to base class' version - (Allows base class to perform
  1576.   // initialization such as transfer of control data)
  1577.   //
  1578.   TDialog::SetupWindow();
  1579.  
  1580.   if (!UseNative) {
  1581.     // Does this dialog have a caption
  1582.     //
  1583.     bool hasCaption = (GetStyle() & WS_CAPTION) != 0;
  1584.  
  1585.     // Strip off and add undesirable and desirable styles respectively
  1586.     //
  1587.     ModifyStyle(WS_BORDER|WS_CAPTION|WS_VISIBLE, WS_GROUP|WS_TABSTOP);
  1588.     ModifyExStyle(WS_EX_WINDOWEDGE, 0, SWP_DRAWFRAME);
  1589.  
  1590.     // Adjust dialog's height if we've truncated the caption
  1591.     //
  1592.     if (hasCaption) {
  1593.       TRect dlgRect;
  1594.       GetWindowRect(dlgRect);
  1595.       dlgRect.bottom -= TUIMetric::CyCaption - TUIMetric::CyBorder;
  1596.       SetWindowPos(HWND_BOTTOM, dlgRect, SWP_NOACTIVATE|SWP_NOMOVE);
  1597.     }
  1598.   }
  1599. }
  1600.  
  1601.  
  1602. #endif  
  1603.  
  1604. // ------------------------------------------------------------------------
  1605. // The following routines are used by ObjectWindows when it
  1606. // provides the underlying support for PropertySheet
  1607. // ------------------------------------------------------------------------
  1608. #if !defined(OWL_NATIVECTRL_ALWAYS) && !defined(BI_PLAT_WIN32)
  1609.  
  1610. const int MaxTabTextLen = 100;
  1611. const int ID_TabControl = 0x1000;
  1612.  
  1613. //
  1614. // Used internally [within this module] to match pages and indices
  1615. //
  1616. struct TPageInfo {
  1617.   const TPropertyPage* Page;      // Pointer to PropertyPage within sheet
  1618.   int                  Index;     // Index of the page [zero-based]
  1619. };
  1620.  
  1621. //
  1622. // NOTE: The 'rect' passed in should be initialized to (0,0,0,0)
  1623. //       before invoking this function for the first time...
  1624. //
  1625. static void
  1626. findDlgResInfo(TPropertyPage* page, TRect* rect)
  1627. {
  1628.   // Find/Load/Lock dialog resource and retrieve dimensions
  1629.   //
  1630.   TDialogRes dlgRes(*(page->GetModule()), page->DialogAttr.Name);
  1631.   TRect dlgRect;
  1632.   dlgRes.GetRect(dlgRect);
  1633.  
  1634.   // Store width of widest dialog
  1635.   //
  1636.   if (dlgRect.Width() > rect->Width()) {
  1637.     rect->left = dlgRect.left;
  1638.     rect->right= dlgRect.right;
  1639.   }
  1640.  
  1641.   // Store away the height if this is the tallest resource
  1642.   //
  1643.   if (dlgRect.Height() > rect->Height()) {
  1644.     rect->top = dlgRect.top;
  1645.     rect->bottom = dlgRect.bottom;
  1646.   }
  1647.  
  1648.   // Store away the page's caption
  1649.   //
  1650.   char caption[100];
  1651.   if (dlgRes.GetText(caption, sizeof(caption)))
  1652.     page->SetPageCaption(caption);
  1653. }
  1654.  
  1655. //
  1656. // Computes the size of the sheet, activates the designated 'startPage'
  1657. // and sets focus to the tab control...
  1658. //
  1659. void
  1660. TPropertySheet::SetupWindow()
  1661. {
  1662.   TWindow::SetupWindow();
  1663.  
  1664.   // Initialization when PropertySheet support is provided by ObjectWindows
  1665.   //
  1666.   if (!UseNative) {
  1667.  
  1668.     // Grab a copy of font based on system's UI
  1669.     //
  1670.     Font = new TDefaultGUIFont;
  1671.  
  1672.     // Create Tab control
  1673.     //
  1674.     Tab = new TTabControl(this, ID_TabControl, 0, 0, 100, 100);
  1675.     if (HeaderInfo.dwFlags & PSH_MULTILINETABS)
  1676.       Tab->SetStyle(Tab->GetStyle() | TCS_MULTILINE);
  1677.     Tab->Create();
  1678.  
  1679.     // Initialize Tab's attributes
  1680.     //
  1681.     if (Font)
  1682.       Tab->SetWindowFont(*Font, true);
  1683.  
  1684.     // Retrieve the size of biggest page/dialog
  1685.     // NOTE: As a side-effect, 'findDlgResInfo' also retrieves the
  1686.     //       caption of each dialog from it's resource template...
  1687.     //
  1688.     TRect rect(0, 0, 0, 0);
  1689.     ForEachPage(TActionPageFunc(findDlgResInfo), &rect);
  1690.  
  1691.     // Update tab with entries of each page and select the
  1692.     // tab corresponding to our 'startPage' a page
  1693.     //
  1694.     SyncTabAndPages();
  1695.     Tab->SetSel(HeaderInfo.nStartPage);
  1696.  
  1697.     // Activate the startPage index
  1698.     //
  1699.     SetActivePage(HeaderInfo.nStartPage);
  1700.  
  1701.     // The sizes retrieved from the dialog resources are in
  1702.     // dialog base units: We convert them to screen coordinates..
  1703.     // NOTE: Win95 seems to be aware of 3.1 style dialogs (i.e.
  1704.     //       non-DS_3DLOOK ones) and computes the dialog base units
  1705.     //       accordingly since these dialogs use the bold font.
  1706.     //       At this point we've retrieved the rectangle of the biggest
  1707.     //       dialog. However, the first active dialog is the one used
  1708.     //       to convert that size from DialogUnits to Pels... So mixing
  1709.     //       DS_3DLOOK and non-DS_3DLOOK dialogs with an app. marked
  1710.     //       for an earlier version of Windows may result (what am I
  1711.     //       saying..., WILL RESULT) in incorrect computation of the
  1712.     //       required dimensions...
  1713.     //
  1714.     PRECONDITION(GetActivePage());
  1715.     GetActivePage()->MapDialogRect(rect);
  1716.  
  1717.     // Retrieve sizes of buttons and margins
  1718.     //
  1719.     ComputeMarginAndButton();
  1720.  
  1721.     // Update the size of the sheet & tab and position the page
  1722.     //
  1723.     UpdateTabAndSheetSize(rect);
  1724.     PositionPage(GetActivePage());
  1725.  
  1726.     // Create Buttons; position them and update their state
  1727.     //
  1728.     CreateButtons();
  1729.     UpdateButtons();
  1730.  
  1731.     // Set Focus to tab control [Is this the desired behaviour?]
  1732.     //
  1733.     Tab->SetFocus();
  1734.   }
  1735. }
  1736.  
  1737. //
  1738. // Internal routine used to identify the page at a particular index
  1739. //
  1740. static bool
  1741. matchPageIndex(TPropertyPage* /*pPage*/, int* pArray)
  1742. {
  1743.   if (pArray[0] == pArray[1])
  1744.     return true;
  1745.   else
  1746.     pArray[0]++;
  1747.  
  1748.   return false;
  1749. }
  1750.  
  1751. //
  1752. // Returns a pointer to the object representing the page at the
  1753. // specified index. Returns zero if no page is found.
  1754. //
  1755. TPropertyPage*
  1756. TPropertySheet::PageAtIndex(int index) const
  1757. {
  1758.   PRECONDITION(index < GetPageCount());
  1759.   int counts[]={0, index};
  1760.   TPropertyPage* page = CONST_CAST(TPropertySheet*,
  1761.                 this)->FirstPageThat(TCondPageFunc(matchPageIndex), counts);
  1762.   CHECK(page == PageAtTabIndex(index));
  1763.   return page;
  1764. }
  1765.  
  1766. //
  1767. // Internal callback used to find the index of a particular page
  1768. // within a property sheet.
  1769. //
  1770. static bool
  1771. matchPagePtr(TPropertyPage* pPage, TPageInfo* pageInfo)
  1772. {
  1773.   if (pPage == pageInfo->Page)
  1774.     return true;
  1775.   else {
  1776.     pageInfo->Index++;
  1777.     return false;
  1778.   }
  1779. }
  1780.  
  1781. //
  1782. // Returns the index of the specified page or '-1' if the
  1783. // specified page could not be found in the child list of
  1784. // the sheet object
  1785. //
  1786. int
  1787. TPropertySheet::IndexOfPage(const TPropertyPage* page) const
  1788. {
  1789.   PRECONDITION(page);
  1790.   TPageInfo pi = {page, 0};
  1791.   int index = CONST_CAST(TPropertySheet*,
  1792.      this)->FirstPageThat(TCondPageFunc(matchPagePtr), &pi) ? pi.Index : -1;
  1793.   CHECK(index == TabIndexOfPage(page));
  1794.   return index;
  1795. }
  1796.  
  1797.  
  1798.  
  1799. DEFINE_RESPONSE_TABLE1(TPropertySheet, TWindow)
  1800.   // Messages handled by Sheet
  1801.   //
  1802.   EV_WM_ACTIVATE,
  1803.   EV_WM_SETFOCUS,
  1804.   EV_WM_SIZE,
  1805.   EV_WM_GETFONT,
  1806.  
  1807.   // Tab Control Notifications
  1808.   //
  1809.   EV_TCN_SELCHANGE(ID_TabControl, TabSelChange),
  1810.   EV_TCN_SELCHANGING(ID_TabControl, TabSelChanging),
  1811.   EV_TCN_KEYDOWN(ID_TabControl, TabKeyDown),
  1812.  
  1813.   // Button notifications
  1814.   //
  1815.   EV_COMMAND_AND_ID(ID_APPLY,  ButtonClicked),
  1816.   EV_COMMAND_AND_ID(ID_BACK,   ButtonClicked),
  1817.   EV_COMMAND_AND_ID(ID_NEXT,   ButtonClicked),
  1818.   EV_COMMAND_AND_ID(ID_FINISH, ButtonClicked),
  1819.   EV_COMMAND_AND_ID(IDOK,      ButtonClicked),
  1820.   EV_COMMAND_AND_ID(IDCANCEL,  ButtonClicked),
  1821.   EV_COMMAND_AND_ID(IDHELP,    ButtonClicked),
  1822. END_RESPONSE_TABLE;
  1823.  
  1824. //
  1825. // Returns a unique name under which the PropertSheet will be
  1826. // registered..
  1827. //
  1828. char*
  1829. TPropertySheet::GetClassName()
  1830. {
  1831.   // When encapsulating the Common Control's implementation we're
  1832.   // unaware of and not concerned with the window's classname
  1833.   // since the Common Control DLL exposes a high level DLL to
  1834.   // create the interface...
  1835.   //
  1836.   return "OWL_PropertySheet";
  1837. }
  1838.  
  1839. //
  1840. // Updates the Window CLASS attributes of the PropertySheet.
  1841. //
  1842. void
  1843. TPropertySheet::GetWindowClass(WNDCLASS& wndClass)
  1844. {
  1845.   TWindow::GetWindowClass(wndClass);
  1846.   wndClass.hbrBackground = HBRUSH(COLOR_BTNFACE + 1);
  1847. }
  1848.  
  1849. //
  1850. // WM_SIZE Handler
  1851. //
  1852. void
  1853. TPropertySheet::EvSize(uint sizeType, TSize& size)
  1854. {
  1855.   TWindow::EvSize(sizeType, size);
  1856.   if (!UseNative) {
  1857.     PRECONDITION(Tab && Tab->GetHandle());
  1858.  
  1859.     // Resize tab control
  1860.     //
  1861.   }
  1862. }
  1863.  
  1864. //
  1865. // WM_ACTIVATE Handler
  1866. //
  1867. void
  1868. TPropertySheet::EvActivate(uint active, bool minimized, THandle other)
  1869. {
  1870.   if (!UseNative) {
  1871.     // Store the handle of the focus window when we
  1872.     // are deactivated...
  1873.     //
  1874.     if (active == WA_INACTIVE)
  1875.       FocusHwnd = GetFocus();
  1876.   }
  1877.   TWindow::EvActivate(active, minimized, other);
  1878. }
  1879.  
  1880. //
  1881. // WM_SETFOCUS Handler
  1882. //
  1883. void
  1884. TPropertySheet::EvSetFocus(HWND hWndLostFocus)
  1885. {
  1886.   if (!UseNative) {
  1887.     // Restore focus to the saved 'Focus' window
  1888.     //
  1889.     if (FocusHwnd && ::IsWindow(FocusHwnd))
  1890.       ::SetFocus(FocusHwnd);
  1891.   }
  1892.   TWindow::EvSetFocus(hWndLostFocus);
  1893. }
  1894.  
  1895. //
  1896. // WM_GETFONT Handler
  1897. //
  1898. HFONT
  1899. TPropertySheet::EvGetFont()
  1900. {
  1901.   if (!UseNative) {
  1902.     if (Font) {
  1903.       return *Font;
  1904.     }
  1905.   }
  1906.   return HFONT(DefaultProcessing());
  1907. }
  1908.  
  1909. //
  1910. // TCN_SELCHANGE Handler
  1911. //
  1912. void
  1913. TPropertySheet::TabSelChange(TNotify&)
  1914. {
  1915.   if (!UseNative) {
  1916.     int index = Tab->GetSel();
  1917.     SetActivePage(index);
  1918.   }
  1919.   else {
  1920.     DefaultProcessing();
  1921.   }
  1922. }
  1923.  
  1924. //
  1925. // TCN_SELCHANGING Handler
  1926. //
  1927. bool
  1928. TPropertySheet::TabSelChanging(TNotify&)
  1929. {
  1930.   if (!UseNative) {
  1931.     // Do not veto any tab changes
  1932.     //
  1933.     return false;
  1934.   }
  1935.   else {
  1936.     return DefaultProcessing() != 0;
  1937.   }
  1938. }
  1939.  
  1940. //
  1941. // TCN_KEYDOWN Handler
  1942. //
  1943. void
  1944. TPropertySheet::TabKeyDown(TTabKeyDown&)
  1945. {
  1946.   if (!UseNative) {
  1947.     //
  1948.     // NOP
  1949.   }
  1950.   else {
  1951.     DefaultProcessing();
  1952.   }
  1953. }
  1954.  
  1955. //
  1956. // WM_COMMAND, code==0 (BN_CLICKED) handler
  1957. //
  1958. void            
  1959. TPropertySheet::ButtonClicked(uint id) 
  1960. {
  1961.   if (UseNative)
  1962.     DefaultProcessing();
  1963.   else {
  1964.     switch (id) {
  1965.       case  IDOK:
  1966.             Apply();
  1967.             CloseWindow(id);
  1968.             break;
  1969.  
  1970.       case  IDCANCEL:
  1971.             Destroy(id);
  1972.             break;
  1973.  
  1974.       case  ID_APPLY:
  1975.             Apply();
  1976.             break;
  1977.  
  1978.       case  IDHELP:
  1979.             TPropertyPage *activePg = GetActivePage();
  1980.             if (activePg != NULL) {
  1981.               TPshNotify info(*this, 0, PSN_HELP, 0);
  1982.               activePg->SendNotification(PropPageID, info);
  1983.             }
  1984.             break;
  1985.  
  1986.     }
  1987.   }
  1988. }
  1989.  
  1990. //
  1991. //
  1992. //
  1993. HWND
  1994. TPropertySheet::CreateButton(int id, const char* caption)
  1995. {
  1996.   return ::CreateWindow("BUTTON", caption, BS_PUSHBUTTON|WS_CHILD|WS_GROUP|
  1997.                         WS_TABSTOP|WS_VISIBLE, 0, 0, 0, 0, *this, HMENU(id),
  1998.                         *GetModule(), 0);
  1999. }
  2000.  
  2001. //
  2002. // Position the buttons of the property sheet
  2003. //
  2004. bool
  2005. TPropertySheet::CreateButtons()
  2006. {
  2007.   char rc[_MAX_PATH];
  2008.   int size = defBtnSz;
  2009.   TSheetBtnInfo* info = defBtn;
  2010.   for (int i=0; i<size; i++) {
  2011.     char* p = GetModule()->LoadString(info[i].strId, rc, sizeof(rc)) ? 
  2012.                                       rc : info[i].defStr;
  2013.  
  2014.     // Special case PSH_NOAPPLYNOW
  2015.     //
  2016.     if (info[i].id == int(ID_APPLY) && 
  2017.        (HeaderInfo.dwFlags & PSH_NOAPPLYNOW))
  2018.       continue;
  2019.  
  2020.     // Create button and initialize its attributes
  2021.     //
  2022.     HWND btn = CreateButton(defBtn[i].id, p);
  2023.     if (!btn)
  2024.       return false;
  2025.     if (Font)
  2026.       ::SendMessage(btn, WM_SETFONT, WPARAM(HFONT(*Font)), TRUE);  
  2027.   }
  2028.  
  2029.   // If user requested HASHELP style, create a Help button.
  2030.   //
  2031.   if (HeaderInfo.dwFlags & PSH_HASHELP) {
  2032.     char* p = GetModule()->LoadString(hlpBtn.strId, rc, sizeof(rc))
  2033.       ? rc : hlpBtn.defStr;
  2034.     HWND btn = CreateButton(hlpBtn.id, p);
  2035.     if (!btn)
  2036.       return false;
  2037.     if (Font)
  2038.       ::SendMessage(btn, WM_SETFONT, WPARAM(HFONT(*Font)), TRUE);
  2039.   }
  2040.  
  2041.   return true;
  2042. }
  2043.  
  2044. //
  2045. //
  2046. bool
  2047. TPropertySheet::UpdateButtons()
  2048. {
  2049.   TRect rect;
  2050.   GetClientRect(rect);
  2051.   int x = rect.right  - (Margin+ButtonSize.cx);
  2052.   int y = rect.bottom - (Margin+ButtonSize.cy);
  2053.   HWND btn;
  2054.   
  2055.   // If there is a Help button, position it.
  2056.   //
  2057.   if (HeaderInfo.dwFlags & PSH_HASHELP) {
  2058.     btn = GetDlgItem(hlpBtn.id);
  2059.     if (btn) {
  2060.       ::MoveWindow(btn, x, y, ButtonSize.cx, ButtonSize.cy, TRUE);
  2061.       x -= (Margin+ButtonSize.cx);
  2062.       ::EnableWindow(btn, 
  2063.                      (bool)(GetActivePage()->PageInfo.dwFlags & PSP_HASHELP));
  2064.     }
  2065.   }
  2066.   
  2067.   for (int i=0; i<sizeof(defBtn)/sizeof(defBtn[0]); i++) {
  2068.     btn = GetDlgItem(defBtn[i].id);
  2069.     if (btn) {
  2070.       ::MoveWindow(btn, x, y, ButtonSize.cx, ButtonSize.cy, TRUE);
  2071.       x -= (Margin+ButtonSize.cx);
  2072.     }
  2073.   }     
  2074.  
  2075.   
  2076.   btn = GetDlgItem(ID_APPLY);
  2077.   if (btn)
  2078.     ::EnableWindow(btn, ApplyEnabled ? TRUE : FALSE);
  2079.  
  2080.   return true; 
  2081. }
  2082.  
  2083. //
  2084. // Returns the TProperPage* of the active page
  2085. //
  2086. TPropertyPage*
  2087. TPropertySheet::GetActivePage() const
  2088. {
  2089.   return (ActiveIndex < 0) ? 0 : PageAtIndex(ActiveIndex);
  2090. }
  2091.  
  2092. //
  2093. // Activates the page at the specified index
  2094. //
  2095. bool
  2096. TPropertySheet::SetActivePage(int index)
  2097. {
  2098.   PRECONDITION(index < GetPageCount());
  2099.   PRECONDITION(index < Tab->GetCount());
  2100.   PRECONDITION(GetHandle());
  2101.  
  2102.   // Retrieve pointer to page
  2103.   //
  2104.   TPropertyPage* page = PageAtIndex(index);
  2105.   CHECK(page);
  2106.  
  2107.   // Create the page/dialog if necessary
  2108.   //
  2109.   if (!page->GetHandle()) {
  2110.     if (!page->GetParentO())
  2111.       page->SetParent(this);
  2112.     page->Create();
  2113.   }
  2114.  
  2115.   // If it's the very first page, skip the positioning - we're in a
  2116.   // catch-22 [The sheet/tab can only be positioned after the first
  2117.   // page is created since we need a page to invoke MapDialogRect, and
  2118.   // the page can only be positioned after the sheet/tab has been
  2119.   // positioned.]
  2120.   //
  2121.   if (ActiveIndex == -1) {
  2122.     ActiveIndex = index;
  2123.     return true;
  2124.   }
  2125.  
  2126.   // Position page if it's not current active and hide current
  2127.   //
  2128.   TPropertyPage* curActive = GetActivePage();
  2129.   if (curActive != page) {
  2130.     PositionPage(page);
  2131.     if (curActive)
  2132.       curActive->ShowWindow(SW_HIDE);
  2133.   }
  2134.  
  2135.   // Select appropriate tab, if necessary
  2136.   //
  2137.   if (Tab->GetSel() != index)
  2138.     Tab->SetSel(index);
  2139.  
  2140.   // Update 'ActiveIndex'
  2141.   //
  2142.   ActiveIndex = index;
  2143.  
  2144.   // Enable or disable the Help button, if present, according the the
  2145.   // style flags of the newly selected page.
  2146.   //
  2147.   HWND btn = GetDlgItem(IDHELP);
  2148.   if (btn) {
  2149.     ::EnableWindow(btn, (bool)(page->PageInfo.dwFlags & PSP_HASHELP));
  2150.   }
  2151.  
  2152.   return true;
  2153. }
  2154.  
  2155. //
  2156. // Callback used to set the text of tab items to the captions of a page.
  2157. //
  2158. static void
  2159. addTabItems(TPropertyPage* page, TTabControl* tab)
  2160. {
  2161.   // Retrieve the caption of the page
  2162.   //
  2163.   char txt[MaxTabTextLen];
  2164.   page->GetPageCaption(txt, sizeof(txt));
  2165.  
  2166.   // Set the text and have the tab control store the pointer
  2167.   // to the page in the application-defined space allocated
  2168.   // to each tab entry...
  2169.   //
  2170.   tab->Add(TTabItem(txt, 0, TParam2(page)));
  2171. }
  2172.  
  2173. //
  2174. // Synchronize tabs labels with current pages of the sheet
  2175. //
  2176. void
  2177. TPropertySheet::SyncTabAndPages()
  2178. {
  2179.   // Clear every tab item
  2180.   //
  2181.   Tab->DeleteAll();
  2182.  
  2183.   // Add the dialog/page titles to the tabs
  2184.   //
  2185.   ForEachPage(TActionPageFunc(addTabItems), Tab);
  2186. }
  2187.  
  2188. //
  2189. // Computes size/spacing of buttons using the active dialog and predefined
  2190. // dialog base units measurements
  2191. //
  2192. void
  2193. TPropertySheet::ComputeMarginAndButton()
  2194. {
  2195.   PRECONDITION(GetActivePage());
  2196.  
  2197.   // Margin       == 5 dlg units
  2198.   // Button Size  == 50x15 dlg units
  2199.   //
  2200.   TRect rect(5, 0, 50, 15); 
  2201.   GetActivePage()->MapDialogRect(rect);
  2202.   ButtonSize.cx = rect.right;
  2203.   ButtonSize.cy = rect.bottom;
  2204.   Margin = rect.left;
  2205. }
  2206.  
  2207. //
  2208. // Update the sheet's size to accomodate a page of the specified size.
  2209. //
  2210. void
  2211. TPropertySheet::UpdateTabAndSheetSize(const TRect& pageRect)
  2212. {
  2213.   // Update the tab's size to that it contains the page within its client
  2214.   // area...
  2215.   //
  2216.   TRect rect = pageRect;
  2217.   Tab->AdjustRect(true, rect);
  2218.   rect.MoveTo(Margin, Margin);
  2219.   Tab->SetWindowPos(0, rect, SWP_NOZORDER|SWP_NOACTIVATE);
  2220.  
  2221.   // Now update the sheet so that it contains the tab within its client area...
  2222.   //
  2223.   AdjustWindowRectEx(rect, GetStyle(), false, GetExStyle());
  2224.  
  2225.   // Lengthen the sheet to leave room for button and widen for margins
  2226.   //
  2227.   rect.bottom += ButtonSize.cy + Margin*3;
  2228.   rect.right += Margin*2;
  2229.  
  2230.   // Move sheet in relation to parent/owner
  2231.   //
  2232.   if (GetParentO() && GetParentO()->GetHandle()) {
  2233.     TRect rc;
  2234.     GetParentO()->GetWindowRect(rc);
  2235.     rect.MoveTo(rc.left + TUIMetric::CyMenu, rc.top + TUIMetric::CyMenu);
  2236.     if (rect.left < 0)
  2237.       rect.MoveTo(-rect.left, rect.top);
  2238.     else if (rect.right > TUIMetric::CxScreen)
  2239.       rect.MoveTo(TUIMetric::CxScreen-rect.Width(), rect.top);
  2240.     if (rect.top < 0)
  2241.       rect.MoveTo(rect.left, -rect.top);
  2242.     else if (rect.bottom > TUIMetric::CyScreen)
  2243.       rect.MoveTo(rect.left, TUIMetric::CyScreen-rect.Height());
  2244.   }
  2245.  
  2246.   // Update the sheet's size to accomodate
  2247.   //
  2248.   SetWindowPos(0, rect, SWP_NOZORDER|SWP_NOACTIVATE);
  2249. }
  2250.  
  2251. //
  2252. // Update a page's location within the sheet
  2253. //
  2254. void
  2255. TPropertySheet::PositionPage(TPropertyPage* page)
  2256. {
  2257.   // Retrieve area of tab (in terms of sheet window)
  2258.   //
  2259.   TRect rect;
  2260.   Tab->GetWindowRect(rect);
  2261.   ::MapWindowPoints(HWND_DESKTOP, *this, LPPOINT(&rect), 2);
  2262.  
  2263.   // Retrieve size of page
  2264.   //
  2265.   TRect pgRect;
  2266.   page->GetWindowRect(pgRect);
  2267.  
  2268.   // Request the tab for it's client area's rectangle
  2269.   //
  2270.   Tab->AdjustRect(false, rect);
  2271.  
  2272.   // Center the page
  2273.   //
  2274.   if (pgRect.Width() < rect.Width())
  2275.     rect.left += (rect.Width() - pgRect.Width())/2;
  2276.   if (pgRect.Height() < rect.Height())
  2277.     rect.top  += (rect.Height()- pgRect.Height())/2;
  2278.   page->SetWindowPos(HWND_TOP, rect, SWP_NOSIZE|SWP_SHOWWINDOW|SWP_NOACTIVATE);
  2279. }
  2280.  
  2281. //
  2282. // Returns the index of the tab item representing the specified page. Returns 
  2283. // -1 if the page is not currently represented by a tab item.
  2284. //
  2285. int
  2286. TPropertySheet::TabIndexOfPage(const TPropertyPage* page) const
  2287. {
  2288.   PRECONDITION(page);
  2289.   PRECONDITION(Tab && Tab->GetHandle());
  2290.  
  2291.   int i = Tab->GetCount();
  2292.   while(i) {
  2293.     TTabItem item(TCIF_PARAM);
  2294.     Tab->GetItem(--i, item);
  2295.     if (item.lParam == LPARAM(page))
  2296.       return i;
  2297.   }
  2298.   return -1;
  2299. }
  2300.  
  2301. //
  2302. // Returns the TPropertyPage pointer represented by the tab item at the 
  2303. // specified 'index'. Returns '0' if there are no tab items at the specified 
  2304. // index.
  2305. //
  2306. TPropertyPage*
  2307. TPropertySheet::PageAtTabIndex(int index) const
  2308. {
  2309.   PRECONDITION(index >= 0);
  2310.   PRECONDITION(Tab && Tab->GetHandle());
  2311.  
  2312.   TTabItem item(TCIF_PARAM);
  2313.   if (Tab->GetItem(index, item)) {
  2314.     return (TPropertyPage*)item.lParam;
  2315.   }
  2316.   return 0;
  2317. }
  2318. #endif
  2319.